1. Field of the Invention
This invention relates generally to computer software architectures, and more particularly to a system and method enabling a plurality of computers and associated computer resources, some or all of which may be heterogeneous in configuration, to cooperatively process a variety of applications such that the user sees the same image of the application no matter where the application is actually executing.
2. Description of the Related Art
In today's processing environment, business applications may be designed and implemented to operate in either a transaction mode or an interactive mode. Transaction mode is normally used when implementing applications within an environment in which many users are competing for limited resources. Interactive mode is most effectively used when resources can be dedicated to a user. In either mode, sharing of processor, data base, and/or terminal resources is normally limited to a homogeneous set of processors, operating systems, and/or transaction processing monitors.
Applications implemented using the transaction model, generally are structured as shown in FIG. 1. Each application load module includes logic for initialization, data import, data processing, data export, and termination.
Application logic is most frequently written in "C" or COBOL program languages. User interface (e.g., screen format) control tables are defined and packaged separately from the application's load module, although there is strong coupling between the user interface definition and the application's data processing logic. Working storage contains data elements which are in a form directly usable by the application program.
Looking now at FIG. 1, initialization logic 12 provides for opening data sets, connecting to any data bases needed for the particular instance of the application, and initializing working storage 10 to default values. Complex applications are implemented as dialogs consisting of several transaction executions per unit of work. This implementation mode is referred to as "conversational transactions" and requires that the state of the conversation be saved and restored for each transaction execution. Conversational transactions maintain the conversation state in working storage 10. At initialization, working storage 10 is refreshed from a copy which was saved at the time the transaction last terminated (for a given terminal).
Data import logic transforms an input data stream 22 from a hardware-dependent representation into the data elements comprising working storage 10. The data stream 22 could originate from a (terminal) device or from another transaction. In the case of devices, the application program logic 12 for data stream 22 decomposition is coupled with, and reflects, device characteristics. In the case of data received from transactions, the application program logic 12 is coupled with the data representation syntax and semantics of the sender.
Data processing logic 14 performs the computation and data manipulation for the application. Information is read from and written to system data base(s) 18, data files, and/or other information systems. Application-dependent integrity checks are performed. Queries are made of the information systems and the responses placed in working storage.
Data export logic 16 transforms working storage 10 data elements into a hardware-dependent representation. The destination for the output data stream 24 can either be a device or a transaction. In the case of devices, the application program logic for data stream 24 formatting is coupled with, and reflects, device characteristics. In the case of data transmitted to transactions, the data representation syntax and semantics of the data stream 24 must match the receiver's application logic.
Termination logic 16 includes closing data sets and committing any logical data base transactions which occurred during this execution instance of the application. If this is a conversational transaction, the current application state (working storage) is saved.
The interactive model provides applications with dedicated resources, including memory, data bases, files, and terminal. Implementation of conversational dialogs is easier than with the transaction model since the application state does not have to be explicitly saved/restored on every interaction with a terminal communications with other processors is achieved through "remote procedure calls" (RPC). RPCs are sometimes also used within the transaction model, or between interactive processes and transactions. In any of these cases, an RPC requires that the calling procedure (with all of its resources), the communications resource, and the called procedure (with all of its resources) be dedicated during the time of the call. Furthermore, the calling procedure's resources (such as the terminal) can not, in general, be used by the called procedure. RPCs have the same characteristics as inter-transaction data transfers, namely that the data representation syntax and semantics of the data stream must be synchronized between the client and server sides of an RPC.
There are however, many difficulties encountered with today's technology. For example, application source code is not portable. Much of the application logic is dependent upon a particular transaction processing monitor, operating system, data base management system, processor type, terminal devices, and/or other variations in the software environment. A very high degree of homogeneity between software environments is required to minimize the cost of porting applications from one environment to another. Multiple sets of source code are required to support the variations in software environment, with the attendant maintenance and function synchronization problems.
As a result of the above, programmers must be trained to generate source code for each specific software environment. Not only is this a waste of training resources, but this amounts to high costs in programmer time in generating source code to enable an application to meet the pecularities of each particular environment.
As indicated above, user interface control tables (e.g., screen formats) are packaged separately from application program logic. This results in synchronization problems at execution time. In most cases, a synchronized update to both user interface control tables and application program logic can not be performed in real time. In order to avoid data integrity problems, application updates require that the application is taken offline and all pending input for the transaction is flushed prior to installation. Application logic is, nevertheless, tightly coupled with specific device characteristics, requiring application changes to support new user interface technology.
Conversational transactions require explicit application program logic to save/restore working storage. The conversation state is maintained with respect to a (terminal) device, not a user. If a user changes terminals, he can not resume the conversation which he started at the original device. Any software modifications to a conversational transaction which results in a redefinition or restructuring of the elements in working storage can not be implemented in real-time. In order to avoid data integrity problems, application updates require that the application is taken offline and all saved working storage reinitialized prior to installation.
Inter-transaction communications, including resource (e.g., transaction, terminal) sharing across distributed systems, is restricted to one instance of a single-image transaction processing system, and also requires synchronized installation of communicating application transactions. A synchronized update, across multiple systems, can not be performed in real time. In order to avoid data integrity problems, application updates require that all involved transactions be taken offline and all pending communications be flushed prior to installation.
Currently available techniques for cooperative processing require dedicated communications resources, dedicated processes, implementation-specific/complex program interfaces, and often asymmetric logic between user and server. For these reasons, it is difficult to quickly implement cooperative processing for small applications. Furthermore, some of the performance/cost objectives associated with a transaction model are compromised by excessive resource consumption associated with direct inter-application communication.
Implementation of business applications in interactive mode is not generally appropriate for high volume applications due to the lack of flexibility in the administration/control of computer resources, in addition to the inability to modify active, distributed applications in real time.